import java.util.concurrent.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;

public class MultiThreadChecker {

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(5); // 假设有5个子线程  
        List<Future<?>> futures = new ArrayList<>();
        CountDownLatch latch = new CountDownLatch(5); // 等待5个子线程  
        AtomicReference<Boolean> resultHolder = new AtomicReference<>(null); // 用于存储结果

        // 启动子线程  
        for (int i = 0; i < 5; i++) {
            int taskId = i;
            futures.add(executor.submit(() -> {
                try {
                    // 模拟子线程任务  
                    boolean result = simulateTask(taskId);
                    // 如果有线程返回false，则设置resultHolder并中断其他线程  
                    if (!result && resultHolder.compareAndSet(null, false)) {
                        // 注意：这里只是设置了结果，并不会直接中断其他线程，  
                        // 但主线程会检查这个结果并据此结束。  
                    } else if (resultHolder.get() == null) {
                        // 如果没有线程返回false，则尝试设置true（注意，可能多个线程同时到达这里）  
                        resultHolder.compareAndSet(null, true);
                    }
                } finally {
                    latch.countDown(); // 计数减一  
                }
            }));
        }

        // 等待所有子线程完成  
        latch.await();

        // 检查并输出结果  
        if (resultHolder.get() == null) {
            // 理论上不应该发生，除非有异常发生导致latch没有正确计数  
            System.out.println("Error: Unexpected result.");
        } else if (resultHolder.get()) {
            System.out.println("alltrue");
        } else {
            System.out.println("false");
        }

        // 关闭ExecutorService  
        executor.shutdown();
    }

    // 模拟子线程任务，随机返回true或false  
    private static boolean simulateTask(int taskId) {
        // 假设我们有一个简单的逻辑来决定是否返回true或false  
        // 这里为了演示，我们简单地基于taskId的奇偶性来决定  
        return taskId % 2 == 0;
    }
}